{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c9781c5b",
   "metadata": {},
   "source": [
    "# 考虑信息泄露的单量子门优化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a84813af",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.linalg as lg\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import *\n",
    "\n",
    "import random\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import collections\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "71cbc68a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class quantum_gate:\n",
    "    def __init__(self,  \n",
    "                 gate_time = 40, \n",
    "                 dt = 2, \n",
    "                 target_gate = np.mat([[0, 1, 0], [1, 0, 0], [0, 0, 1]], dtype = complex), \n",
    "                 preprocess = False):\n",
    "        self.preprocess = preprocess\n",
    "        self.dimension = np.shape(target_gate)[0]\n",
    "        self.gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.history_gate = np.mat(np.identity(self.dimension), dtype = complex) #记录上一步的状态\n",
    "        self.history_gate_2 = np.mat(np.identity(self.dimension), dtype = complex) #记录上上步的状态\n",
    "        self.target_gate = target_gate #默认目标是实现X门\n",
    "        self.nstep = 0\n",
    "        self.gate_time = gate_time\n",
    "        self.dt = dt\n",
    "        self.sx = np.mat([[0, 1], [1, 0]], dtype = complex)\n",
    "        self.sz = np.mat([[1, 0], [0, -1]], dtype = complex)\n",
    "        self.sy = np.mat([[0, -1j], [1j, 0]], dtype = complex)\n",
    "        self.drive = np.mat([[0, 1, 0], [1, 0, 1], [0, 1, 0]], dtype = complex)\n",
    "        self.leak = - 2 * np.pi * 0.25 * np.mat([[0, 0, 0], [0, 0, 0], [0, 0, 1]], dtype = complex)\n",
    "        self.strength_low = -0.1 * np.pi * 2\n",
    "        self.strength_high = 0.1 * np.pi * 2\n",
    "        self.name = \"optimal quantum gate\"\n",
    "        self.done = 0\n",
    "        self.fidelity = [0]\n",
    "        \n",
    "        self.observe_state()\n",
    "        \n",
    "    \n",
    "    \n",
    "    def observe_state(self):#因为神经网络不能识别复数矩阵，所以要把实部虚部分开，并展成一维数组，喂给神经网络   \n",
    "        if self.preprocess == False:\n",
    "            self.state = []\n",
    "            \n",
    "            #加入历史信息，传给神经网络\n",
    "            temp = np.array(self.history_gate_2[0:2,0:2]).flatten()\n",
    "            for item in temp:\n",
    "                self.state.append(item.real)\n",
    "                self.state.append(item.imag)\n",
    "            \n",
    "            temp = np.array(self.history_gate[0:2,0:2]).flatten()\n",
    "            for item in temp:\n",
    "                self.state.append(item.real)\n",
    "                self.state.append(item.imag)\n",
    "            \n",
    "            temp = np.array(self.gate[0:2,0:2]).flatten()\n",
    "            for item in temp:\n",
    "                self.state.append(item.real)\n",
    "                self.state.append(item.imag)\n",
    "            \n",
    "            self.state.append(self.nstep)\n",
    "            self.state = np.array(self.state)\n",
    "        else:\n",
    "            determinant = np.linalg.det(self.gate)\n",
    "            phase = np.sqrt(determinant)\n",
    "            SU2_gate = self.gate / phase\n",
    "\n",
    "            a = SU2_gate[0,0]\n",
    "            b = SU2_gate[0,1]\n",
    "            a_mod = np.sqrt(a.real ** 2 + a.imag ** 2)\n",
    "            b_mod = np.sqrt(b.real ** 2 + b.imag ** 2)\n",
    "            A = a.real / a_mod if a_mod != 0 else 0\n",
    "            B = b.imag / b_mod if b_mod != 0 else 0\n",
    "            \n",
    "            beta = (np.arccos(a_mod) + np.arcsin(b_mod)) / np.pi\n",
    "            alpha = (np.arccos(A) + np.arcsin(B)) / np.pi\n",
    "            gamma = (np.arccos(A) - np.arcsin(B)) / np.pi\n",
    "\n",
    "            self.state = np.array([beta, alpha, gamma])\n",
    "        return\n",
    "    \n",
    "    def reset(self):\n",
    "        self.gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.history_gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.history_gate_2 = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.observe_state()\n",
    "        self.nstep = 0\n",
    "        self.done = 0\n",
    "        self.fidelity = [0]\n",
    "        return self.state\n",
    "    \n",
    "    def Hamiltonian(self, strength):\n",
    "        H = -strength / 2 * self.drive + self.leak\n",
    "        #sz的强度应该远小于sx\n",
    "        return H\n",
    "    \n",
    "    def reward(self):\n",
    "        current_gate = self.gate[0:2,0:2]\n",
    "        target_gate = self.target_gate[0:2,0:2]\n",
    "        dimension = np.shape(current_gate)[0]\n",
    "        \n",
    "        projection = target_gate.H * current_gate\n",
    "        trace = np.array(projection.trace()).flatten()[0] \n",
    "        fidelity = ((trace/dimension).real)**2 + ((trace/dimension).imag)**2\n",
    "\n",
    "        err = 1 - fidelity\n",
    "\n",
    "        reward = -np.log(err) if self.done == 1 else 0\n",
    "        \n",
    "\n",
    "        \n",
    "        self.fidelity.append(fidelity)\n",
    "        return [reward, fidelity]\n",
    "    \n",
    "    def step(self, strength):\n",
    "        self.history_gate_2 = self.history_gate\n",
    "        self.history_gate = self.gate\n",
    "        U = lg.expm(-1j * self.Hamiltonian(strength) * self.dt)\n",
    "        U = np.mat(U)\n",
    "        self.gate = U * self.gate\n",
    "        self.observe_state()\n",
    "        \n",
    "        self.nstep += 1\n",
    "        self.done = self.nstep * self.dt >= self.gate_time\n",
    "        reward, fidelity = self.reward()\n",
    "\n",
    "        \n",
    "        return [self.state, reward, self.done, fidelity, self.gate]\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8096811d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    ''' 经验回放池 '''\n",
    "    def __init__(self, capacity):\n",
    "        self.buffer = collections.deque(maxlen=capacity) # 队列，先进先出\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        self.buffer.append((state, action, reward, next_state, done)) # 将数据加入buffer\n",
    "\n",
    "    def sample(self, batch_size): # 从buffer中采样数据，数量为batch_size\n",
    "        transitions = random.sample(self.buffer, batch_size)\n",
    "        state, action, reward, next_state, done = zip(*transitions)\n",
    "        return np.array(state), action, reward, np.array(next_state), done\n",
    "\n",
    "    def size(self): # 目前buffer中数据的数量\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "de5c8e91",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SumTree(object):\n",
    "    #我尝试过把PER加入算法中，不过毕设时间仓促，没有调出来\n",
    "    \"\"\"\n",
    "    This SumTree code is a modified version and the original code is from:\n",
    "    https://github.com/jaara/AI-blog/blob/master/SumTree.py\n",
    "    Story data with its priority in the tree.\n",
    "    \"\"\"\n",
    "    data_pointer = 0\n",
    "\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity  # for all priority values\n",
    "        self.tree = np.zeros(2 * capacity - 1)\n",
    "        # [--------------Parent nodes-------------][-------leaves to recode priority-------]\n",
    "        #             size: capacity - 1                       size: capacity\n",
    "        self.data = np.zeros(capacity, dtype=object)  # for all transitions\n",
    "        # [--------------data frame-------------]\n",
    "        #             size: capacity\n",
    "\n",
    "    def add(self, p, data):\n",
    "        tree_idx = self.data_pointer + self.capacity - 1\n",
    "        self.data[self.data_pointer] = data  # update data_frame\n",
    "        self.update(tree_idx, p)  # update tree_frame\n",
    "\n",
    "        self.data_pointer += 1\n",
    "        if self.data_pointer >= self.capacity:  # replace when exceed the capacity\n",
    "            self.data_pointer = 0\n",
    "\n",
    "    def update(self, tree_idx, p):\n",
    "        change = p - self.tree[tree_idx]\n",
    "        self.tree[tree_idx] = p\n",
    "        # then propagate the change through tree\n",
    "        while tree_idx != 0:    # this method is faster than the recursive loop in the reference code\n",
    "            tree_idx = (tree_idx - 1) // 2\n",
    "            self.tree[tree_idx] += change\n",
    "\n",
    "    def get_leaf(self, v):\n",
    "        \"\"\"\n",
    "        Tree structure and array storage:\n",
    "        Tree index:\n",
    "             0         -> storing priority sum\n",
    "            / \\\n",
    "          1     2\n",
    "         / \\   / \\\n",
    "        3   4 5   6    -> storing priority for transitions\n",
    "        Array type for storing:\n",
    "        [0,1,2,3,4,5,6]\n",
    "        \"\"\"\n",
    "        parent_idx = 0\n",
    "        while True:     # the while loop is faster than the method in the reference code\n",
    "            cl_idx = 2 * parent_idx + 1         # this leaf's left and right kids\n",
    "            cr_idx = cl_idx + 1\n",
    "            if cl_idx >= len(self.tree):        # reach bottom, end search\n",
    "                leaf_idx = parent_idx\n",
    "                break\n",
    "            else:       # downward search, always search for a higher priority node\n",
    "                if v <= self.tree[cl_idx]:\n",
    "                    parent_idx = cl_idx\n",
    "                else:\n",
    "                    v -= self.tree[cl_idx]\n",
    "                    parent_idx = cr_idx\n",
    "\n",
    "        data_idx = leaf_idx - self.capacity + 1\n",
    "        return leaf_idx, self.tree[leaf_idx], self.data[data_idx]\n",
    "    \n",
    "    @property\n",
    "    def total_p(self):\n",
    "        return self.tree[0]  # the root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "69613102",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Memory(object):  # stored as ( s, a, r, s_ ) in SumTree\n",
    "    #我尝试过把PER加入算法中，不过毕设时间仓促，没有调出来\n",
    "    \"\"\"\n",
    "    This Memory class is modified based on the original code from:\n",
    "    https://github.com/jaara/AI-blog/blob/master/Seaquest-DDQN-PER.py\n",
    "    \"\"\"\n",
    "    epsilon = 0.01  # small amount to avoid zero priority\n",
    "    alpha = 0.6  # [0~1] convert the importance of TD error to priority\n",
    "    beta = 0.4  # importance-sampling, from initial value increasing to 1\n",
    "    beta_increment_per_sampling = 0.001\n",
    "    abs_err_upper = 1.  # clipped abs error\n",
    "\n",
    "    def __init__(self, capacity):\n",
    "        self.tree = SumTree(capacity)\n",
    "\n",
    "    def store(self, transition):\n",
    "        #找出这个数组倒数capacity个数中的最大值，实际上就是找出sum tree的叶子节点的最大值\n",
    "        max_p = np.max(self.tree.tree[-self.tree.capacity:]) \n",
    "        if max_p == 0:\n",
    "            max_p = self.abs_err_upper\n",
    "        self.tree.add(max_p, transition)   # set the max p for new p\n",
    "\n",
    "    def sample(self, n):\n",
    "        b_idx, b_memory, ISWeights = np.empty((n,), dtype=np.int32), np.empty((n, self.tree.data[0].size)), np.empty((n, 1))\n",
    "        pri_seg = self.tree.total_p / n       # priority segment\n",
    "        self.beta = np.min([1., self.beta + self.beta_increment_per_sampling])  # max = 1\n",
    "\n",
    "        min_prob = np.min(self.tree.tree[-self.tree.capacity:]) / self.tree.total_p     # for later calculate ISweight\n",
    "        for i in range(n):\n",
    "            a, b = pri_seg * i, pri_seg * (i + 1)\n",
    "            v = np.random.uniform(a, b)\n",
    "            idx, p, data = self.tree.get_leaf(v)\n",
    "            prob = p / self.tree.total_p\n",
    "            ISWeights[i, 0] = np.power(prob/min_prob, -self.beta)\n",
    "            b_idx[i], b_memory[i, :] = idx, data\n",
    "        return b_idx, b_memory, ISWeights\n",
    "\n",
    "    def batch_update(self, tree_idx, abs_errors):\n",
    "        abs_errors += self.epsilon  # convert to abs and avoid 0\n",
    "        clipped_errors = np.minimum(abs_errors, self.abs_err_upper)\n",
    "        ps = np.power(clipped_errors, self.alpha)\n",
    "        for ti, p in zip(tree_idx, ps):\n",
    "            self.tree.update(ti, p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "586f91c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Qnet(torch.nn.Module):\n",
    "    ''' 一层隐层的Q网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(Qnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, 600)\n",
    "#         self.fc2 = torch.nn.Linear(600, 600)\n",
    "        self.fc2 = torch.nn.Linear(600, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "#         x = F.relu(self.fc2(x))\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7bc5051d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class VAnet(torch.nn.Module):\n",
    "    ''' 一层隐层的A网络和V网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(VAnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, 1200) # 共享网络部分\n",
    "        \n",
    "        self.fc_A = torch.nn.Linear(1200, action_dim)\n",
    "        self.fc_V = torch.nn.Linear(1200, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        A = self.fc_A(F.relu(self.fc1(x)))\n",
    "        V = self.fc_V(F.relu(self.fc1(x)))\n",
    "        Q = V + A - A.mean(1).view(-1, 1) # Q值由V值和A值计算得到\n",
    "        return Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "93cdfcdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN:\n",
    "    ''' DQN算法，包括Double DQN和Double Dueling DQN '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma, epsilon, target_update, device, dqn_type='VanillaDQN'):\n",
    "        self.action_dim = action_dim\n",
    "        if dqn_type == 'DuelingDQN': # Dueling DQN采取不一样的网络框架\n",
    "            self.q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "            self.target_q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "#             self.ans_q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "        else:\n",
    "            self.q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "            self.target_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "#             self.ans_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "\n",
    "\n",
    "#         self.best_fidelity = 0\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(), lr=learning_rate)\n",
    "#       ***********************************************************************************\n",
    "#         gamma = 1-1e-4\n",
    "        gamma = 1\n",
    "#       ***********************************************************************************\n",
    "        self.my_rl_scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer = self.optimizer, gamma = gamma) \n",
    "        self.gamma = gamma\n",
    "        self.epsilon = epsilon\n",
    "        self.target_update = target_update\n",
    "        self.count = 0\n",
    "        self.dqn_type = dqn_type\n",
    "\n",
    "    def take_action(self, state):\n",
    "        if np.random.random() < self.epsilon:\n",
    "            action = np.random.randint(self.action_dim)\n",
    "        else:\n",
    "            state = torch.tensor(np.array([state]), dtype=torch.float).to(device)\n",
    "            action = self.q_net(state).argmax().item()\n",
    "        return action\n",
    "    \n",
    "    def final_policy_action(self, state):\n",
    "        state = torch.tensor(np.array([state]), dtype=torch.float).to(device)\n",
    "        action = self.q_net(state).argmax().item()\n",
    "        return action\n",
    "\n",
    "    def max_q_value(self, state):\n",
    "        state = torch.tensor(np.array([state]), dtype=torch.float).to(device)\n",
    "        return self.q_net(state).max().item()\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(device)\n",
    "        actions =  torch.tensor(transition_dict['actions']).view(-1, 1).to(device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(device)\n",
    "\n",
    "        q_values = self.q_net(states).gather(1, actions)\n",
    "        if self.dqn_type == 'DoubleDQN' or self.dqn_type == 'DuelingDQN':\n",
    "            max_action = self.q_net(next_states).max(1)[1].view(-1, 1)\n",
    "            max_next_q_values = self.target_q_net(next_states).gather(1, max_action)\n",
    "        else:\n",
    "            max_next_q_values = self.target_q_net(next_states).max(1)[0].view(-1, 1)\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))\n",
    "        self.optimizer.zero_grad()\n",
    "        dqn_loss.backward()\n",
    "        self.optimizer.step()\n",
    "        agent.my_rl_scheduler.step()\n",
    "\n",
    "        if self.count % self.target_update == 0:\n",
    "            self.target_q_net.load_state_dict(self.q_net.state_dict())\n",
    "        self.count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "030c8183",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dis_to_con(discrete_action, env, action_dim): # 离散动作转回连续的函数\n",
    "    action_lowbound = env.strength_low # 连续动作的最小值\n",
    "    action_upbound = env.strength_high # 连续动作的最大值\n",
    "    return action_lowbound + (discrete_action / (action_dim - 1)) * (action_upbound - action_lowbound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d7540f88",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_DQN(agent, env, num_episodes, replay_buffer_size , minimal_size, batch_size, prioritized = False):\n",
    "    return_list = []\n",
    "    fidelity_list = []\n",
    "    max_q_value_list = []\n",
    "    fid_his = []\n",
    "    fid_test = []\n",
    "    max_q_value = 0\n",
    "    \n",
    "#     evaluate_num = 20\n",
    "    evaluate_num = 1\n",
    "    evaluate_fidelity = []\n",
    "    evaluate_average_fidelity = []\n",
    "    \n",
    "    if prioritized == False:\n",
    "        replay_buffer = ReplayBuffer(buffer_size)\n",
    "    else:\n",
    "        replay_buffer = Memory(buffer_size)\n",
    "    \n",
    "    for i in range(10):\n",
    "        with tqdm(total=int(num_episodes/10), desc='Iteration %d' % i) as pbar:\n",
    "            for i_episode in range(int(num_episodes/10)):\n",
    "                episode_return = 0\n",
    "                state = env.reset()\n",
    "                done = False\n",
    "                while not done:\n",
    "                    action = agent.take_action(state)\n",
    "                    max_q_value = agent.max_q_value(state) * 0.005 + max_q_value * 0.995 # 平滑处理\n",
    "                    max_q_value_list.append(max_q_value) # 保存每个状态的最大Q值\n",
    "                    action_continuous = dis_to_con(action, env, agent.action_dim)\n",
    "                    next_state, reward, done, fidelity, _ = env.step(action_continuous)\n",
    "                    \n",
    "#                     if fidelity > agent.best_fidelity:#记录最好的训练结果\n",
    "#                         agent.best_fidelity = fidelity\n",
    "#                         agent.ans_q_net.load_state_dict(agent.q_net.state_dict())\n",
    "                    \n",
    "                    if prioritized == False:\n",
    "                        replay_buffer.add(state, action, reward, next_state, done)\n",
    "                    else:\n",
    "                        replay_buffer.store([state, action, reward, next_state, done])\n",
    "                        \n",
    "                    \n",
    "#                     for i in range(test_at_ecah_step):\n",
    "#                         fid_test[episode * test_at_ecah_step + i][0] = episode\n",
    "#                         fid_test[episode * test_at_ecah_step + i][1] = test_maze()\n",
    "        \n",
    "#                     fid_his.append(fid_test[episode * test_at_ecah_step : (episode + 1) * test_at_ecah_step, 1].mean())\n",
    "                    \n",
    "                    state = next_state\n",
    "                    episode_return += reward\n",
    "                    if replay_buffer.size() > minimal_size:\n",
    "                        b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(max(batch_size, int(0.1 * replay_buffer.size())))\n",
    "                        transition_dict = {'states': b_s, 'actions': b_a, 'next_states': b_ns, 'rewards': b_r, 'dones': b_d}\n",
    "                        agent.update(transition_dict)\n",
    "                return_list.append(episode_return)\n",
    "                fidelity_list.append(fidelity)\n",
    "                \n",
    "                #使用平均fidelity评估当前策略\n",
    "                temp = 0\n",
    "                for j in range(evaluate_num):\n",
    "                    evaluate_DQN(agent, env)\n",
    "                    temp += env.fidelity[-1]\n",
    "                    evaluate_fidelity.append([i * num_episodes/10 + i_episode, env.fidelity[-1]])\n",
    "                evaluate_average_fidelity.append(temp / evaluate_num)\n",
    "                \n",
    "#                 if i >=2:\n",
    "#                     agent.my_rl_scheduler.step() #训练了一段时间后，要适当降低学习率\n",
    "                \n",
    "                if (i_episode+1) % 10 == 0:\n",
    "                    pbar.set_postfix({'episode': '%d' % (num_episodes/10 * i + i_episode+1), 'return': '%.3f' % np.mean(return_list[-10:])})\n",
    "                pbar.update(1)\n",
    "    return return_list, max_q_value_list, fidelity_list, evaluate_fidelity, evaluate_average_fidelity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b69d3cb",
   "metadata": {},
   "source": [
    "### 实现调试功能的代码"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7a483312",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_DQN(agent, env):\n",
    "    state = env.reset()\n",
    "#     fidelity_list = []\n",
    "#     fidelity_list.append(env.reward()[1])\n",
    "    action_list = []\n",
    "    debug_list = []\n",
    "    done = False\n",
    "    while not done:\n",
    "        action = agent.final_policy_action(state)\n",
    "        debug_list.append(action)\n",
    "        action_continuous = dis_to_con(action, env, agent.action_dim)\n",
    "        action_list.append(action_continuous)\n",
    "        next_state, reward, done, fidelity, _ = env.step(action_continuous)\n",
    "        state = next_state\n",
    "    \n",
    "    return action_list, debug_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a3bd3f79",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_sequence(x, dt=2):\n",
    "#     action_num = 13\n",
    "    \n",
    "    env = quantum_gate(dt=dt/100)#这里为了画的精细一点，专门把dt从默认的2变成了0.02\n",
    "    \n",
    "    data_his = []\n",
    "    data_his.append(env.gate)\n",
    "    fid_his = []\n",
    "    fid_his.append(env.reward()[1])\n",
    "    \n",
    "\n",
    "    \n",
    "    for i in range(len(x)):\n",
    "        for j in range(100):\n",
    "            strength = x[i]\n",
    "            _, reward, done, fidelity, gate = env.step(strength)\n",
    "            data_his.append(gate)\n",
    "            fid_his.append(fidelity)\n",
    "    \n",
    "    plt.figure()\n",
    "#     plt.plot(fid_his)  \n",
    "    \n",
    "    plt.plot(np.arange(len(fid_his)) * env.dt, fid_his)\n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Real time fidelity')\n",
    "    plt.title('DDDQN on single qubit gate')\n",
    "    print(\"fidelity = \", fid_his[-1])\n",
    "    \n",
    "    \n",
    "    temp = env.gate[0,1]\n",
    "    phase = np.exp(-1j*np.angle(temp))\n",
    "#     phase = np.sqrt(np.linalg.det(env.gate))\n",
    "    print(env.gate * phase)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36996fd7",
   "metadata": {},
   "source": [
    "# 研究项目：DDDQN对于存在信息泄露问题的单量子门，保真度最高能优化到多少"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba179a06",
   "metadata": {},
   "source": [
    "### 训练周期4000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "13faa3fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|████████████████████████████████████████| 400/400 [00:56<00:00,  7.10it/s, episode=400, return=2.274]\n",
      "Iteration 1: 100%|████████████████████████████████████████| 400/400 [01:09<00:00,  5.76it/s, episode=800, return=2.532]\n",
      "Iteration 2: 100%|███████████████████████████████████████| 400/400 [01:35<00:00,  4.18it/s, episode=1200, return=2.599]\n",
      "Iteration 3: 100%|███████████████████████████████████████| 400/400 [01:40<00:00,  3.98it/s, episode=1600, return=2.545]\n",
      "Iteration 4: 100%|███████████████████████████████████████| 400/400 [01:40<00:00,  3.99it/s, episode=2000, return=3.094]\n",
      "Iteration 5: 100%|███████████████████████████████████████| 400/400 [01:36<00:00,  4.13it/s, episode=2400, return=4.241]\n",
      "Iteration 6: 100%|███████████████████████████████████████| 400/400 [01:34<00:00,  4.23it/s, episode=2800, return=3.925]\n",
      "Iteration 7: 100%|███████████████████████████████████████| 400/400 [01:34<00:00,  4.23it/s, episode=3200, return=4.037]\n",
      "Iteration 8: 100%|███████████████████████████████████████| 400/400 [01:38<00:00,  4.07it/s, episode=3600, return=4.915]\n",
      "Iteration 9: 100%|███████████████████████████████████████| 400/400 [01:37<00:00,  4.12it/s, episode=4000, return=6.127]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last epoch fidelity =  0.9989179073766566\n",
      "final agent output fidelity =  0.9989179073766566\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# random.seed(0)\n",
    "# np.random.seed(0)\n",
    "# torch.manual_seed(0)\n",
    "\n",
    "lr = 0.0001\n",
    "num_episodes = 4000\n",
    "hidden_dim = 128\n",
    "# gamma = .95\n",
    "gamma = .95\n",
    "epsilon = 0.01\n",
    "target_update = 100\n",
    "# buffer_size = 100000\n",
    "buffer_size = 20000\n",
    "minimal_size = 1000\n",
    "batch_size = 900 #72\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "\n",
    "env = quantum_gate()\n",
    "\n",
    "state_dim = np.shape(env.state)[0]\n",
    "action_dim = 13  # 将连续动作分成13个离散动作\n",
    "\n",
    "\n",
    "#注意一下，这里虽然参数是DuelingDQN，但实际使用的是Double Dueling DQN，我完成算法时才意识到忘记改了\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon, target_update, device, \"DuelingDQN\")\n",
    "\n",
    "\n",
    "return_list, max_q_value_list, fidelity_list, evaluate_fidelity, evaluate_average_fidelity = train_DQN(agent, env, num_episodes, buffer_size, minimal_size, batch_size)\n",
    "\n",
    "\n",
    "frames_list = list(range(len(max_q_value_list)))\n",
    "plt.plot(frames_list, max_q_value_list)\n",
    "plt.xlabel('Frames')\n",
    "plt.ylabel('Max Q value')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(return_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Inverse of logarithm of infidelity ')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(fidelity_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy with epsilon greedy ')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "\n",
    "print(\"last epoch fidelity = \", fidelity_list[-1])\n",
    "\n",
    "\n",
    "action_list, debug_list = evaluate_DQN(agent, env)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(np.arange(len(env.fidelity)) * env.dt, env.fidelity)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Real time fidelity')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.step(np.arange(len(action_list)) * env.dt, action_list)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Omega')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "print(\"final agent output fidelity = \", env.reward()[1])\n",
    "\n",
    "evaluate_fidelity = np.array(evaluate_fidelity)\n",
    "plt.figure()\n",
    "plt.plot(evaluate_average_fidelity)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy without epsilon greedy')\n",
    "plt.title('DDDQN on  single qubit gate')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "27ceaeca",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fidelity =  0.9989179073765654\n",
      "[[ 0.01665338-1.11265923e-03j  0.99966709-1.07552856e-16j\n",
      "  -0.01954157+2.29625712e-03j]\n",
      " [ 0.99920221-1.38987934e-02j -0.01682588-2.43265530e-04j\n",
      "  -0.00453551+3.31365328e-02j]\n",
      " [ 0.0334381 -2.25623342e-03j  0.00352393-1.92387942e-02j\n",
      "   0.09197528-9.95004925e-01j]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_sequence(action_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2f2fb948",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|████████████████████████████████████████| 400/400 [00:55<00:00,  7.26it/s, episode=400, return=6.551]\n",
      "Iteration 1: 100%|████████████████████████████████████████| 400/400 [01:10<00:00,  5.68it/s, episode=800, return=5.860]\n",
      "Iteration 2: 100%|███████████████████████████████████████| 400/400 [01:37<00:00,  4.11it/s, episode=1200, return=6.455]\n",
      "Iteration 3: 100%|███████████████████████████████████████| 400/400 [01:37<00:00,  4.12it/s, episode=1600, return=6.131]\n",
      "Iteration 4: 100%|███████████████████████████████████████| 400/400 [01:38<00:00,  4.06it/s, episode=2000, return=5.939]\n",
      "Iteration 5: 100%|███████████████████████████████████████| 400/400 [01:40<00:00,  3.97it/s, episode=2400, return=5.713]\n",
      "Iteration 6: 100%|███████████████████████████████████████| 400/400 [01:38<00:00,  4.05it/s, episode=2800, return=6.829]\n",
      "Iteration 7: 100%|███████████████████████████████████████| 400/400 [01:33<00:00,  4.26it/s, episode=3200, return=6.103]\n",
      "Iteration 8: 100%|███████████████████████████████████████| 400/400 [01:35<00:00,  4.17it/s, episode=3600, return=6.780]\n",
      "Iteration 9: 100%|███████████████████████████████████████| 400/400 [01:44<00:00,  3.84it/s, episode=4000, return=6.051]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last epoch fidelity =  0.9989179073766566\n",
      "final agent output fidelity =  0.9989179073766566\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAApZklEQVR4nO3debhVdd3+8fcNIg6AImAqiCCihqmlOJWVU6WmaWYpZg5lZmZZPWXaZP56KrNsMFOyQS17NHOeMjEzs5zAxCkHRFHUBE0UZ4HP74+1jmw2e++zzj57rT3dr+s619lr/uwFZ33Xd1ZEYGZm3WtAswMwM7PmckJgZtblnBCYmXU5JwRmZl3OCYGZWZdzQmBm1uWcEJj1gaQXJK3fgPMcIunGRsTUx+t+S9I5NbbfI2mH4iKyVuCEoAtJekTSy5IWSlog6Z+SjpA0oGSfsyS9lu6zUNLdkr4nabWSfQ6RtDh9OL4g6WFJZ0rasOx6g9NjH02v+6CkL0lSyT7XS3pF0rol63aR9EjOt6NPImJIRMxudhx5iYhNIuJ66D3R6K/03/ywvM5v2Tkh6F57RsRQYD3gROArwK/L9jkp3WcUcCiwLfAPSauW7HNTRAwBVgN2AV4GZkh6S8k+fwR2BnYHhgIfAz4FnFx2vReBbzTgu5lZHzgh6HIR8VxEXAbsBxxc9gDv2eeViLgN+AAwgiRRKN9ncUQ8FBFHAn8DvgUgaWfgvcCHIuLuiFgUETcDBwJHlxWznAJMkbRBltglvV3SbZKeS3+/vWTb9ZK+LekfaY7mGkkjM553A0l/S8/7tKQ/lGyLnvjSXNPPJV2ZXuMWSRNK9n2vpPvT85yWnrPiG7CkjSVNk/Tf9JiP1IhvfHquhekxp/a8uUvaQdLcsv0fkbRLyaqVJP0hPf52SZuX7ytpV+CrwH5pbm9mlVi2kPSv9Fx/TM/7v+m24ZKukDRf0rPp5zHptu8A7wROTc9/al/vgzWOEwIDICJuBeaS/HFW22chMK3WPqmLSvZ5D3BLRDxWdq5b0uvtXLL6ceCXpIlILZLWAK4kSTxGAD8CrpQ0omS3A0gSrTWBFYEv9Xbe1LeBa4DhwBjgZzX2nQKckO47C/hOGt9I4ALguDS++4G3VzpBmsOaBvxfGusU4DRJm1S55v8BM4CRaawHZ/xePfYiyaWtkZ7rEkmDSneIiKuB7wJ/SIvDNi8/iaQVgYuBs9JznQt8sGSXAcCZJLnOsSS5xVPT838N+DtwVHr+o+q4D9YgTgis1BMkf9CN3Gck8GSV/Z4kKXYq9T1gzwx//O8HHoyI36W5jHOB+4A9S/Y5MyIeiIiXgfOBt/Zyzh6vkzy81klzQ7UqdS+KiFsjYhHw+5Jr7A7cExEXpdtOAf5T5Rx7AI9ExJnpd7kduBDYt3xHSWOBrYBvRMSrEXEDcHnG79VjRkRcEBGvkySgK5EU+/XVtsAKwCkR8XpEXATc2rMxIp6JiAsj4qX0JeI7wLtrnC/zfbDGckJgpUYD/23wPk8Da1fZb21gfumKiJhP8tb4/3q5xjrAnLJ1c9Jr9yh98L4EDOnlnD2OAQTcqqQVzcdr7FvtGusAb+SCIhndcZkimxLrAdsoqbhfIGkB8FFgrQr7rgM8GxEvlqwrvw+9KY1rSRrXOn08R08sj8eyI1e+cW5Jq0j6haQ5kp4HbgBWlzSwyvn6ch+sgZwQGACStiJ5iFZ9+5U0hKRC+O+9nO6DJftcS/LHvW7pDpK2JikuuKHC8T8AdgS2rHGNJ0geHKXGkhQv9UtE/CciPhkR65BUap+Wtd6ixJMkxUoASFLpcpnHgL9FxOolP0Mi4tNVzju8rMJ+bMnnF4FVSq47kOVzXaUtswakcT1R4Vq9DU38JDA6/W7LnRv4H2AjYJuIGAa8q+eyVc7fl/tgDeSEoMtJGiZpD+A84JyIuKvCPoMlbQlcAjxLUu5bvs/AtBLzZ8AOJOXmRMS1wF+ACyVtku63LUkxym8j4v7yc0XEApIWRcfUCP0qYENJB0haQdJ+wCTgiuzfvjJJH+6p1CT5vgEs7uNprgQ2lbS3pBWAz1D9zfYKku/yMUmD0p+tJL25fMeImANMB06QtKKk7Vm2OOwBksrg96fl/l8HBpedZktJ+6RxfR54Fbi5QlxPAeNU0qy4zE0k9+Wo9N9gL2Drku1DSeoFFqR1OsdXOH9pY4HM98EaywlB97pc0kKSt7CvkZQVl7cGOibd57/Ab0kqKN9eViyxnaQXgOeB64FhwFZlCcqHgL8CVwOvkDxArgYOrxHfT6nx8I2IZ0jKlP8HeIYk0dgjIp6ucc6stgJuSb/XZcDREfFwX06QxvFh4KQ0vkkkD/BXK+y7kKRl1f4kb+b/Ab7P8g/wHgcA25D8uxxP8m/Tc67ngCOBX5Hkjl5k+SKpS0laiT1L0pR3n7S+oNwf09/PSLq9QtyvAfsAnwAWkLQEu6LkO/4EWJmkePBmkn/zUj8F9k1bFJ1Sx32wBpEnprGiSTqbpBhq9/Rh0vHSt+q5wEcj4q8NPve3gA0i4sBGnrfOWG4BpkbEcrlGa13OEVgzHEbSTHCLZgeSJ0nvk7S6pMEkbfJF5SKYtiXp3ZLWSouGDgY2Y/k3f2txKzQ7AOs+aTHE95sdRwG2I2kTvyJwL7B32pS1k2xE0jR3CPAQsG9EVGsubC3KRUNmZl3ORUNmZl2u7YqGRo4cGePGjWt2GGZmbWXGjBlPR0R5nxKgDROCcePGMX369GaHYWbWViRV7YHuoiEzsy7nhMDMrMs5ITAz63JOCMzMupwTAjOzLpdbQiDpN5LmSbq7ynZJOkXSLEl3Suro4QbMzFpVnjmCs4Bda2zfDZiY/hwOnJ5jLGZmVkVu/Qgi4gZJ42rsshfJePQB3JwOzrV2XuOUPPDUQq66a+mpFy0OrrtvHqOGDmbQwAEMW2kF5i18lRtnLR3FePN1V+eV1xZz/1ML+dxOG/DF92603HkXLV7C6dc/xI+vfYA9NluHkz+yOUsi2Ojrybhbe26+DuuPXJU9N1+bDdYc2muc1933FB8/a2k/iQ3WHML7N12bZab+MLOuNHm9Ndh+4siGn7eZHcpGUzKtHckQvaOpML+tpMNJx64fO3Zs+eZMHnzqBX5y7YPLb6iR7Mx8bMEbn0+5blbFhOD86XM5edoDAFw28wkGDhCz57/wxvbLZyYTP81b+Arf22ezXuMsTQQAZs17gZ/+pULcZtZ1jnj3hOYkBJLWiIje5qitR6V33Ioj4EXEGcAZAJMnT65rlLzdN12Lh7+3+xvLn/rdDK6596l6TrWMxWWD9l1515O8tmjJMuvWGrYSi5fUDnuvU29k5tznKm77+zE7Mmb4yv0L1Mysiiw5glsk3UEyPeGfonHDlc5l2flNq82b2hBqQNnK8ZfezRE7TODDU2/irEO3YoM1h/KNS5atCy9PBJJr937uaokAwFqrrdSQ+M3MKslSWbwhydv4x4BZkr4racMGXPsy4KC09dC2wHOtPo752TfNYbvvXcfcZ19mlx9VmnN9eTcft3Nd1/rGHpM4ZcrbeOTE9zNooFv5mll+es0RpDmAacA0STsC5wBHSpoJHBsRN1U6TtK5JJOYj5Q0l2Ru1UHpOaeSTD6+OzALeInl58st3O8P24bzpz/GpXckGZPbvrYLL7y6iB1/eH3d51xrtZXqOu4T24+v+5pmZn2RpY5gBMmk1B8DngI+S/I2/1aSya0rPrEiYkqt86YJzGf6Fm7jrbriQF58LZkj/R0bjOQdG4xk5mMLGCAxauhgRg31vNlm1tmy1BHcBPyOZJq9uSXrp0uamk9Y+eup6Dj5I2/liHNmLLPt+i/v2JBrnHf4tg05j5lZnrIkBBtVqyCOiLadd7bnGxVVB+sZQc2sVVVNCCRdTvriXKnFSkR8IL+wOoPKfpuZtaJaOYIfpr/3AdYiqSQGmAI8kmNMBUle0fvzkH70mZcaE4qZWRNVTQgi4m8Akr4dEe8q2XS5pGxtJ9tAf9rnL3j5tQZGYmbWHFkaqI+StH7PgqTxQMUJkLtNL52FzczaQpbK4i8A10uanS6PAz6VW0QFaUTlbW+drN0b2MzaQZYOZVdLmghsnK66LyJezTes9tCoHEHjRu0wM+u7XouGJK0CfBk4KiJmAmMl7ZF7ZDnrefT27509+wO80p6z57/AK68v5txbH1tm/fBVBvUrKjOzvshSNHQmMAPYLl2eS9Kj+Iq8gmoXWXME5UVE5976KBfMmMuMOc/yvk3exJpDlx2GYoCLlMysQFkqiydExEnA6wAR8TId0DS+pzimP8/cekp0Hn76RY676C5mzHkWgD/f8xSz5r2wzD6uWzCzImXJEbwmaWWWdi6bAHRUHcGY4Svz9gkj+nxcPWX7ry9efpjqm2Y/s8zyAKcDZlagLAnB8cDVwLqSfg+8Azgkz6CKduNXdqrruN6SgUov9lme8cNWdh2BmRUnS6uhaZJuB7YleY4dHRFP93JYy3ujsrgfb99L6sgRZLmecwRmVqQsrYYE7AZsGRFXAKtI2jr3yNpBXa0+/ZQ3s9aSpbL4NJIWQz3zCywEfp5bRAV5Y/TRfjyYs7YaenzBy1wwYy63P/pspv3drcDMipQlIdgmIj4DvAIQEc8CK+YaVZH602qoj1mCfU77Jw88tbDX/XbaeM16QzIz67MsCcHrkgaytNXQKGD5pi9dqLccQaU05pkXex+o7phdN+51HzOzRsmSEJwCXAysKek7wI3Ad3ONqgCNKH3Ja2iIga4tNrMC1Ww1JGkA8DBwDLAzyUvu3hHx7wJia3n1JAN+xJtZq6mZEETEEkknR8R2wH0FxVSIN3oW9+skDQnFzKypshQNXSPpQ+rQcQ/687Xy6kdgZlakLD2LvwisCiyS9ArJS3RExLBcI2sDvaUDlXsWOyUws9aSpWfx0CICaUd55Ag8BLWZFa3XhEDSFhVWPwfMiYhFjQ+pfeRRRTBh1JAczmpmVl2WoqHTgC2Au9LlTYGZwAhJR0TENXkFl6elPYv7c446cgT9uJ6ZWR6yVBY/ArwtIraMiC2BtwJ3A7sAJ+UXWjGKno/AzKzVZEkINo6Ie3oWIuJekoRhdo1jWl5fh4eofI7eLJ/K9JbwuFWRmRUtS9HQ/ZJOB85Ll/cDHpA0mHTWsnbWn1Y89eQI3GrIzFpNlhzBIcAs4PPAF4DZ6brXgR1ziit3jSjWqafVkNMBM2s1vSYEEfFyRJwcER+MiL0j4ocR8VJELImIF2odK2lXSfdLmiXp2ArbV5N0uaSZku6RdGh/vkwncL2DmRUtS46gLumIpT8nmdRmEjBF0qSy3T4D3BsRmwM7ACdL6pwhrs3M2kBuCQGwNTArImZHxGskdQx7le0TwNB0+IohwH+BQvomvNF8NMeimnrmLHZlsZkVLc+EYDTwWMny3HRdqVOBNwNPkPRTODoiCp3roF/9COq5np/0ZtZisvQs3hD4MrBe6f4RsVNvh1ZYV/7sfB9wB7ATMAGYJunvEfF8WQyHA4cDjB07treQM2lE89F6eKoBM2s1WZqP/hGYCvwSWNyHc88F1i1ZHkPy5l/qUODESLrozpL0MLAxcGvpThFxBnAGwOTJkxv7BO/Hg9nPdDPrBFkSgkURcXod574NmChpPPA4sD9wQNk+j5JMePN3SW8CNiJpntoRhq/iem8za31ZEoLLJR1JMl3lqz0rI+K/tQ6KiEWSjgL+DAwEfhMR90g6It0+Ffg2cJaku0hesL8SEU/X91X6phHNNHs7xfiRq/b5nO5wZmZFy5IQHJz+/nLJugDW7+3AiLgKuKps3dSSz08A780QQ26KfvCefdOcQq9nZtabLPMRjC8ikKI1q9/WzMcW1NzerEpsM+tevTYflTRI0uckXZD+HCWp7WdPGTN8ZQCGrpQlU2Rm1rmyPAVPBwaRzEsA8LF03WF5BVWE/937LbznzW/iLaNXq/sc9cxHYGbWarIkBFulQ0D0uE7SzLwCKsoqK67Abpuu3ewwluPKYjMrWpaexYslTehZkLQ+fetP0Pa2GLt6xfXuJWxmnSBLjuDLwF8lzSZp4rkeSUewrvHOiaO4/dEFzQ7DzCwXWVoN/UXSRJLOXgLui4hXezmso1R78XcdgZl1gqoJgaR9qmyaIImIuCinmLqbS5vMrGC1cgR71tgWQNckBK7ANbNOVjUhiIiuqgdoGS5tMrOC1SoaOjAizpH0xUrbI+JH+YXVuv5x7E6848Trmh2GmVnD1Coa6hkxbWgRgbQLFxKZWaepVTT0i/T3CcWFY05pzKxoWcYaOknSsHTMob9IelrSgUUEZ2Zm+cvSs/i96dSRe5DMOtYzdWXX8IigZtbJsiQEPSON7g6c29uENJ3Oo0qYWafJOkPZfcDLwJGSRgGv5BuWmZkVpdccQUQcC2wHTI6I14EXgb3yDqxbOcNhZkXrNUcgaSWSQea2lxTAjSTzEXSlvHsZuzbCzIqWpWjot8BC4Gfp8hTgd8CH8wqq1XhsOTPrZFkSgo3KJqb5aydMTGNmZoksrYb+JWnbngVJ2wD/yC+k1lPaUsithsys02TJEWwDHCTp0XR5LPBvSXcBERGb5RZdiyiyaMjpjJkVLUtCsGvuUbQp1x2YWSfI0nx0DrAusFP6+UVgQETMSZc7np/3ZtbJsow1dDzwFeC4dNWKwDl5BtWqdtp4TRfdmFnHyVJZ/EHgAyQ5ASLiCbpsaOqeh/+mo1drahxmZnnIkhC8Fsks7QEgadVe9u84Lhoys06WJSE4X9IvgNUlfRK4FvhlvmG1Jgk36zGzjtNrq6GI+KGk9wDPAxsB34yIablH1oLcSsjMOlGW5qOkD/6ufPibmXW6LEVDdZO0q6T7Jc2SdGyVfXaQdIekeyT9Lc94+ktadtA5T1hjZp0gU46gHpIGAj8H3kMys9ltki6LiHtL9lkdOA3YNSIelbRmXvH0S4FlQh7CwsyKlqUfwdFZ1lWwNTArImZHxGvAeSw/j8EBwEUR8ShARMzLcN6myXsIajOzZshSNHRwhXWHZDhuNPBYyfLcdF2pDYHhkq6XNEPSQZVOJOlwSdMlTZ8/f36GS+fDRUFm1omqFg1JmkLyxj5e0mUlm4YCz2Q4d6XX5/In6QrAlsDOwMrATZJujogHljko4gzgDIDJkyc39Wmcd9GNWyaZWdFq1RH8E3gSGAmcXLJ+IXBnhnPPJRmjqMcY4IkK+zwdES8CL0q6AdgceIAW5KIhM+tEVROCdEC5OSTzFdfjNmCipPHA48D+JDmMUpcCp0pagWQMo22AH9d5vdwU+ZLuymIzK1qWOYsXsvRZuCIwCHgxIobVOi4iFkk6CvgzMBD4TUTcI+mIdPvUiPi3pKtJchhLgF9FxN31f538+TltZp0mS8/iZQaYk7Q3SYugXkXEVcBVZeumli3/APhBlvM1S7WHv8vzzawT9LlDWURcAuzU+FBal5/3ZtbJshQN7VOyOACYTJc+G11+b2adKEvP4j1LPi8CHmH5jmEdrbQISDmnBm6ZZGZFy1JHcGgRgZiZWXNkGWJijKSLJc2T9JSkCyWNKSK4VlFkkZB7L5tZ0bJUFp8JXAasQzJExOXpuq6xTNFQ88IwM8tFloRgVEScGRGL0p+zgFE5x9WSeksE/t9emxQSh5lZI2VJCJ6WdKCkgenPgWQba6jjlfcjOGi7cf0+pyuLzaxoWRKCjwMfAf5DMvbQvum6ruQmpGbWabK0GnoU+EABsZiZWRNk6VA2CvgkMK50/4jomlxBtZY8zh2YWSfI0qHsUuDvwLXA4nzDMTOzomVJCFaJiK/kHkmbWGby+hya/DuXYWZFy1JZfIWk3XOPpA0U8ZD2iKZmVrRaU1X2zEMg4KuSXgVeT5ejt/kIzMysPdSaoWxotW3dZpm3dBfdmFmHyTLW0F+yrOtGLsUxs05Qq2hoJWBVYKSk4Sx9Fx5GMu6Q5cCVxWZWtFqthj4FfJ7koX97yfrngZ/nGFPLkrTMg9rPbDPrBLXqCH4K/FTSZyPiZwXGZGZmBapVNLRTRFwHPF42XSUAEXFRrpG1gdI6gmlfeFfT4jAz649aRUPvBq5j2akqewTQ9QlBqYlvciMrM2tPtYqGjk9/d/1UlW49amadLMugcw8BN5OMN3RDRNybe1RmZlaYLENMTAJ+AYwAfihptqSL8w2rPYTHgzCzDpAlIVhMMrTEYmAJ8BQwL8+gWs2UrcbypmGD2ftto5Eb+ptZh8ky+ujzwF3Aj4BfRkTXTVM5dsQq3PLVXQB44dVFb6x3omBmnSBLjmAKcANwJHCepBMk7ZxvWO3hpocanyY6bTGzomWZqvJS4FJJGwO7kfQ2PgZYOd/QWt+Ft89tdghmZv2WZdC5C9OWQz8lGXvoIGB43oG1Kr+wm1mnyVJHcCJwe0R4mkozsw7Ua44gIm6rNxGQtKuk+yXNknRsjf22krRY0r71XMfMzOqXpbK4LpIGkoxSuhtJX4QpkiZV2e/7wJ/ziqWRXJlrZp0mt4QA2BqYFRGzI+I14Dxgrwr7fRa4kC7rm2Bm1iqyVha/X1JfE43RwGMly3PTdaXnHg18EJjaSwyHS5ouafr8+fP7GIaZmdWS5eF+OnAA8KCkE9NmpFlUKkQpH5PhJ8BXequDiIgzImJyREweNWpUxsvnQ243ZGYdJks/gmuBayWtRtK5bJqkx4BfAudExOtVDp0LrFuyPAZ4omyfySSd1ABGArtLWhQRl/TpW5iZWd0yFfdIGgEcAhwG/IukT8EWwLQah90GTJQ0XtKKwP7AZaU7RMT4iBgXEeOAC4Ajuz0RcI7DzIqWZRjqi4CNgd8Be0bEk+mmP0iaXu24iFgk6SiS1kADgd9ExD2Sjki316wXMDOzYmTpUHZqOmXlciJicq0DI+Iq4KqydRUTgIg4JEMsTefmo2bWabIUDb1Z0uo9C5KGSzoyv5C6WyxXn25mlq8sCcEnI2JBz0JEPAt8MreI2tzB263X7BDMzPokS0IwQCUD76c9gVfML6T2NnzV/t0aVxabWdGy1BH8GThf0lSSfgBHAFfnGpWZmRUmS0LwFeBTwKdJOoldA/wqz6Damd/ozazdZOlQtoSkd/Hp+YfT+txqyMw6TdWEQNL5EfERSXex/NAQRMRmuUZmZmaFqJUjODr9vUcRgVjCOQ4zK1rVhKCnB3FEzCkuHAt3IzCzgtUqGlrIskVCSpcFREQMyzm2luTKYDPrNLVyBEOLDKRTuGjHzNpNluajSNoceGe6eENE3JlfSO2tUtHOxmsN5b7/LCw+GDOzDLLMUHY08HtgzfTn95I+m3dgraqeN3714SDnKMysaFmGmPgEsE1EfDMivglsi8caqqrSg/zj7xhXeBxmZlllSQgElE4luZjK01BaFR+evC7f3muTZodhZlZRljqCM4FbJF1MkgDsBfw616g60IABTjvNrDVlGWLiR5KuB7ZPVx0aEf/KNaoW5se5mXWaTHMWp0r7EVgfuaOYmbWqLK2GvgmcDQwHRgJnSvp63oGZmVkxstQRTAHeFhGvAEg6Ebgd+N88A2tVvTUFdXbJzNpNlqKhR4CVSpYHAw/lEo2ZmRUuS47gVeAeSdNI6gjeA9wo6RSAiPhcjvF1DFcRmFmrypIQXJz+9Lg+n1Dag4t+zKzTZGk+enYRgXQ8NxsysxbVl+ajZmbWgZwQNJgHjTOzdlM1IZD0u/T30dX26Ua9PehdAmRm7aZWjmBLSesBH5c0XNIapT9FBdgpnD6YWauqVVk8FbgaWB+YwbINZiJdb2VcNGRm7aZqjiAiTomINwO/iYj1I2J8yU/XJgJ9mWSmlIuMzKxV9VpZHBGflrS5pKPSn82ynlzSrpLulzRL0rEVtn9U0p3pzz/TKTHNzKxAWQad+xx1TFUpaSDwc2A3YBIwRdKkst0eBt4dEZsB3wbO6Fv4nafeHIeZWb2y9Cw+jGSqyhcBJH0fuAn4WS/HbQ3MiojZ6XHnkUxqc2/PDhHxz5L9bwbGZA/dzMwaIc+pKkcDj5Usz03XVfMJ4E8VA5AOlzRd0vT58+dnuHTrCVcSmFmL6utUlQB7k22qykqJRcWnoaQdSRKC7Sttj4gzSIuNJk+e3NJPVBftmFm76etUlSL7VJVzgXVLlscAT5TvlFY+/wrYLSKeyRJ0O2rp1MvMulqWHAERcTvJZDR9cRswUdJ44HFgf+CA0h0kjQUuAj4WEQ/08fxmZtYAmRKCekTEIklHAX8GBpL0R7hH0hHp9qnAN4ERwGlpkcqiiJicV0xmZra83BICgIi4CriqbN3Uks+HkbRKMjOzJsnSj+AoScOLCKZdDFup7+mnGw2ZWavK0nx0LeA2SeenPYW7vlnMNuuPWGb5Fx/bskmRmJn1X5YhJr4OTCRpMnoI8KCk70qakHNsLas8JZy09rBejxmQMfns+lTWzAqXaWKaSHpD/Sf9WQQMBy6QdFKOsbWs8lKeLHmk/bcem0ssZmb9lWmsIUkzgJOAfwCbRsSngS2BD+UcX0uqp7x/pUED+dAWHkHDzFpPlhzBSGCfiHhfRPwxIl4HiIglwB65Rtey6qv5ffuEEb3u4zplMytaloRgfETMKV3RM41lRPw7l6haXK0cQa1iokVLljQ+GDOzfsqSEGxSupAOL93VzWRqvbXXSiSWZHjdd2WxmRWt1uT1x0laCGwm6fn0ZyEwD7i0sAhbUPlIollb1LovgZm1olpTVX4vIoYCP4iIYenP0IgYERHHFRhjy6n1PK+VJoRrAMysBVXtIitp44i4D/ijpC3Kt6cD0ZmZWZurNVbC/wCfBE6usC2AnXKJqA24iMfMOknVhCAiPpn+3rG4cNrDch3Ksh6XpbLYtcVmVrBaRUP71DowIi5qfDjtod5pJ7Mc5dyGmRWtVtHQnjW2BcmEMmZm1uZqFQ0dWmQgnUK1Cor8um9mLSjLWENvkvRrSX9KlydJ+kT+obWu8ue5y/XNrJ1l6Vl8Fsl0k+ukyw8An88pnraQZ38AJypmVrRMg85FxPnAEkjmIgYW5xpVi6u3hMcFQ2bWirIkBC9KGkH6HJO0LfBcrlG1uLoTAqcEZtaCsky++0XgMmCCpH8Ao4B9c42qxZUXDdWsIC49zimBmbWgXhOCiLhd0ruBjUj6Tt3fMyeBLc9l/GbWburpULahpC7vUFbfNjOzVpSlQ9mawNuB69LlHYHr6eIOZfU+651GmFkr6rVDmaQrgEkR8WS6vDbw82LCa1E1+hG4aMjM2k2WVkPjehKB1FPAhjnF0xYGD8py25ZXWmz0/Q9t2qBozMz6J8sT7XpJf5Z0iKSDgSuBv+YcV0tbZ7WV6zquNCOx+6ZrNyYYM7N+ytJq6Ki04vid6aozIuLifMPqbOuNWIWhKw2quM0lS2ZWtCz9CHpaCHVt5XCj7bTxms0OwczsDbWaj94YEdunE9aXlmoIiIgYlnt0bSJrk1F3KDOzVlQrR/BRgHQCeytR3rN4SckDPkvRTtaeyGZmRahVWfxGPYCkC+s5uaRdJd0vaZakYytsl6RT0u13Stqinuu0m1pNTCePW6O4QMzMqJ0QlD6u1u/riSUNJOlvsBswCZgiaVLZbrsBE9Ofw4HT+3qdZvjE9svejmErL6343WK94QDsXKEeoFbJ0Mghg5n2hXfx6XdPaEyQZmYZ1Soaiiqfs9oamBURswEknQfsBdxbss9ewG8jKTy/WdLqktYu67fQcjZaa9nSsiGDl97Grcatwd0nvG+ZdT3WXSNpdjp+5KoA/PDDm7Pgpdc47J19TmfNzBqmVkKwuaTnSXIGK6efIXtl8WjgsZLlucA2GfYZDSyTEEg6nCTHwNixY3u5bDFGDR3M/IWvcuI+y3cMq5QIAOz6lrU5/1PbsdW4JNew75Zjco3RzCyLWkNMDOznuSuVhJfnLLLsQ0ScAZwBMHny5JZoenPb13ap67itx7sOwMxaS31jJWQzF1i3ZHkM8EQd+5iZWY7yTAhuAyZKGi9pRWB/kgluSl0GHJS2HtoWeK7V6wfMzDpNpp7F9YiIRZKOIpn4fiDwm4i4R9IR6fapwFXA7sAs4CXg0LziMTOzynJLCAAi4iqSh33puqklnwP4TJ4xmJlZbXkWDZmZWRtwQmBm1uWcEJiZdTknBGZmXU7tNjSypPnAnDoPHwk83cBwGqVV44LWjc1x9Y3j6ptOjGu9iBhVaUPbJQT9IWl6RExudhzlWjUuaN3YHFffOK6+6ba4XDRkZtblnBCYmXW5bksIzmh2AFW0alzQurE5rr5xXH3TVXF1VR2BmZktr9tyBGZmVsYJgZlZl+uahEDSrpLulzRL0rFNuP4jku6SdIek6em6NSRNk/Rg+nt4yf7HpbHeL+l9DYzjN5LmSbq7ZF2f45C0Zfp9Zkk6RVKlSYb6G9e3JD2e3rM7JO3ehLjWlfRXSf+WdI+ko9P1Tb1nNeJq6j2TtJKkWyXNTOM6IV3f7PtVLa6m/x9LzzlQ0r8kXZEuF3u/IqLjf0iGwX4IWB9YEZgJTCo4hkeAkWXrTgKOTT8fC3w//TwpjXEwMD6NfWCD4ngXsAVwd3/iAG4FtiOZZe5PwG45xPUt4EsV9i0yrrWBLdLPQ4EH0us39Z7ViKup9yw9x5D08yDgFmDbFrhf1eJq+v+x9JxfBP4PuKIZf5PdkiPYGpgVEbMj4jXgPGCvJscESQxnp5/PBvYuWX9eRLwaEQ+TzNewdSMuGBE3AP/tTxyS1gaGRcRNkfwP/G3JMY2Mq5oi43oyIm5PPy8E/k0yr3ZT71mNuKopKq6IiBfSxUHpT9D8+1UtrmoK+z8maQzwfuBXZdcv7H51S0IwGnisZHkutf9o8hDANZJmSDo8XfemSGdkS3+vma4vOt6+xjE6/VxEfEdJulNJ0VFP9rgpcUkaB7yN5G2yZe5ZWVzQ5HuWFnPcAcwDpkVES9yvKnFB8/+P/QQ4BlhSsq7Q+9UtCUGlsrKi282+IyK2AHYDPiPpXTX2bYV4oXocRcV3OjABeCvwJHBys+KSNAS4EPh8RDxfa9ciY6sQV9PvWUQsjoi3ksxBvrWkt9TYvdlxNfV+SdoDmBcRM7Iekkdc3ZIQzAXWLVkeAzxRZAAR8UT6ex5wMUlRz1Nplo7097x096Lj7Wscc9PPucYXEU+lf7xLgF+ytHis0LgkDSJ52P4+Ii5KVzf9nlWKq1XuWRrLAuB6YFda4H5ViqsF7tc7gA9IeoSkyHonSedQ8P3qloTgNmCipPGSVgT2By4r6uKSVpU0tOcz8F7g7jSGg9PdDgYuTT9fBuwvabCk8cBEkoqgvPQpjjSrulDStmnLhINKjmmYnj+E1AdJ7lmhcaXn+TXw74j4Ucmmpt6zanE1+55JGiVp9fTzysAuwH00/35VjKvZ9ysijouIMRExjuS5dF1EHEjR9ytrrXK7/wC7k7SseAj4WsHXXp+kpn8mcE/P9YERwF+AB9Pfa5Qc87U01vtpQKuEkvOeS5IFfp3kLeIT9cQBTCb5o3kIOJW0l3qD4/odcBdwZ/oHsHYT4tqeJIt9J3BH+rN7s+9Zjbiaes+AzYB/pde/G/hmvf/XC4qr6f/HSs67A0tbDRV6vzzEhJlZl+uWoiEzM6vCCYGZWZdzQmBm1uWcEJiZdTknBGZmXc4JgXU9SYu1dPTJO9TL6LSSjpB0UAOu+4ikkf09j1l/ufmodT1JL0TEkCZc9xFgckQ8XfS1zUo5R2BWRfrG/n0l49jfKmmDdP23JH0p/fw5Sfemg5adl65bQ9Il6bqbJW2Wrh8h6Rol487/gpLxYSQdmF7jDkm/kDSwCV/ZupQTAjNYuaxoaL+Sbc9HxNYkPTV/UuHYY4G3RcRmwBHpuhOAf6XrvkoyJDDA8cCNEfE2kl6sYwEkvRnYj2RgwrcCi4GPNvILmtWyQrMDMGsBL6cP4ErOLfn94wrb7wR+L+kS4JJ03fbAhwAi4ro0J7AayeQ7+6Trr5T0bLr/zsCWwG3JMDGszNJBxsxy54TArLao8rnH+0ke8B8AviFpE2oPCVzpHALOjojj+hOoWb1cNGRW234lv28q3SBpALBuRPyVZGKR1YEhwA2kRTuSdgCejmSugNL1uwE9k6D8BdhX0prptjUkrZfbNzIr4xyBWVpHULJ8dUT0NCEdLOkWkpemKWXHDQTOSYt9BPw4IhZI+hZwpqQ7gZdYOpzwCcC5km4H/gY8ChAR90r6OskMdgNIRmD9DDCnwd/TrCI3HzWrws07rVu4aMjMrMs5R2Bm1uWcIzAz63JOCMzMupwTAjOzLueEwMysyzkhMDPrcv8fjOAIftMT2WgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "return_list, max_q_value_list, fidelity_list, evaluate_fidelity, evaluate_average_fidelity = train_DQN(agent, env, num_episodes, buffer_size, minimal_size, batch_size)\n",
    "\n",
    "\n",
    "frames_list = list(range(len(max_q_value_list)))\n",
    "plt.plot(frames_list, max_q_value_list)\n",
    "plt.xlabel('Frames')\n",
    "plt.ylabel('Max Q value')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(return_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Inverse of logarithm of infidelity ')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(fidelity_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy with epsilon greedy ')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "\n",
    "print(\"last epoch fidelity = \", fidelity_list[-1])\n",
    "\n",
    "\n",
    "action_list, debug_list = evaluate_DQN(agent, env)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(np.arange(len(env.fidelity)) * env.dt, env.fidelity)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Real time fidelity')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.step(np.arange(len(action_list)) * env.dt, action_list)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Omega')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "print(\"final agent output fidelity = \", env.reward()[1])\n",
    "\n",
    "evaluate_fidelity = np.array(evaluate_fidelity)\n",
    "plt.figure()\n",
    "plt.plot(evaluate_average_fidelity)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy without epsilon greedy')\n",
    "plt.title('DDDQN on  single qubit gate')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5ef183f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fidelity =  0.9989179073765654\n",
      "[[ 0.01665338-1.11265923e-03j  0.99966709-1.07552856e-16j\n",
      "  -0.01954157+2.29625712e-03j]\n",
      " [ 0.99920221-1.38987934e-02j -0.01682588-2.43265530e-04j\n",
      "  -0.00453551+3.31365328e-02j]\n",
      " [ 0.0334381 -2.25623342e-03j  0.00352393-1.92387942e-02j\n",
      "   0.09197528-9.95004925e-01j]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_sequence(action_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "f639dd2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|████████████████████████████████████████| 400/400 [00:57<00:00,  6.94it/s, episode=400, return=5.795]\n",
      "Iteration 1: 100%|████████████████████████████████████████| 400/400 [01:12<00:00,  5.51it/s, episode=800, return=6.108]\n",
      "Iteration 2: 100%|███████████████████████████████████████| 400/400 [01:33<00:00,  4.27it/s, episode=1200, return=6.401]\n",
      "Iteration 3: 100%|███████████████████████████████████████| 400/400 [01:36<00:00,  4.15it/s, episode=1600, return=6.120]\n",
      "Iteration 4: 100%|███████████████████████████████████████| 400/400 [01:37<00:00,  4.09it/s, episode=2000, return=6.161]\n",
      "Iteration 5: 100%|███████████████████████████████████████| 400/400 [01:36<00:00,  4.16it/s, episode=2400, return=6.459]\n",
      "Iteration 6: 100%|███████████████████████████████████████| 400/400 [01:38<00:00,  4.07it/s, episode=2800, return=6.042]\n",
      "Iteration 7: 100%|███████████████████████████████████████| 400/400 [01:38<00:00,  4.08it/s, episode=3200, return=6.829]\n",
      "Iteration 8: 100%|███████████████████████████████████████| 400/400 [01:39<00:00,  4.03it/s, episode=3600, return=6.272]\n",
      "Iteration 9: 100%|███████████████████████████████████████| 400/400 [01:38<00:00,  4.05it/s, episode=4000, return=6.412]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last epoch fidelity =  0.9989179073766566\n",
      "final agent output fidelity =  0.9989179073766566\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "return_list, max_q_value_list, fidelity_list, evaluate_fidelity, evaluate_average_fidelity = train_DQN(agent, env, num_episodes, buffer_size, minimal_size, batch_size)\n",
    "\n",
    "\n",
    "frames_list = list(range(len(max_q_value_list)))\n",
    "plt.plot(frames_list, max_q_value_list)\n",
    "plt.xlabel('Frames')\n",
    "plt.ylabel('Max Q value')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(return_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Inverse of logarithm of infidelity ')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(fidelity_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy with epsilon greedy ')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "\n",
    "print(\"last epoch fidelity = \", fidelity_list[-1])\n",
    "\n",
    "\n",
    "action_list, debug_list = evaluate_DQN(agent, env)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(np.arange(len(env.fidelity)) * env.dt, env.fidelity)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Real time fidelity')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.step(np.arange(len(action_list)) * env.dt, action_list)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Omega')\n",
    "plt.title('DDDQN on single qubit gate')\n",
    "print(\"final agent output fidelity = \", env.reward()[1])\n",
    "\n",
    "evaluate_fidelity = np.array(evaluate_fidelity)\n",
    "plt.figure()\n",
    "plt.plot(evaluate_average_fidelity)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy without epsilon greedy')\n",
    "plt.title('DDDQN on  single qubit gate')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b94f6782",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'DDDQN on  single qubit gate')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAhzklEQVR4nO3debxd0/3/8ddbjCFpQqIlg4SaoqXiErTfVulgjqqWtGpoUVVKJ0Xbr/p1Ut+231ItUkQNjZqF+ipFpFpCYp5SQcIliBqSoiTx+f2x163tOMO+N+fcc3Lu+/l4nMc5ezhrf9a5yfmcvfbaaykiMDMzK7VcswMwM7PW5ARhZmZlOUGYmVlZThBmZlaWE4SZmZXlBGFmZmU5QZjViaR/SVq3DuUcIOmWesTUzeP+QNL5VbY/IGm73ovIms0Jwt5G0hxJr0laKOklSX+XdKik5XL7nCPpjbTPQkn3S/qppHfl9jlA0pL0pfkvSY9LmiRpg5LjrZTe+0Q67iOSviVJuX2mSvq3pBG5dR+TNKfBH0e3RMRqEfFYs+NolIjYJCKmQu1ksrTS3/ygRpVvxThBWDm7RcQAYB3gROA7wFkl+5yU9hkKHAhsDfxN0qq5fW6NiNWAdwEfA14DZkp6X26fi4EdgJ2BAcAXgC8Dvyg53ivA9+tQNzMryAnCKoqIlyNiCrA3sH/JF3vXPv+OiDuA3YE1yJJF6T5LIuLRiDgMuBn4AYCkHYBPAJ+OiPsjYnFE3AbsCxxZ0lxzCjBB0nuLxC5pW0l3SHo5PW+b2zZV0g8l/S2dAV0naUjBct8r6eZU7vOS/pjbFl3xpbOs30j6UzrGdEnr5fb9hKRZqZzfpjLL/mKWtJGk6yW9kN7z2SrxjU5lLUzvObXrl76k7SR1luw/R9LHcqtWlvTH9P47JW1Wuq+kHYHjgL3T2eE9FWIZK+muVNbFqdwfpW2DJV0tab6kF9Pr4Wnbj4H/Ak5N5Z/a3c/B6sMJwmqKiNuBTrL/tJX2WQhcX22f5LLcPh8HpkfEkyVlTU/H2yG3+ingd6TkUo2k1YE/kSWVNYBfAn+StEZut8+RJbM1gRWBb9UqN/khcB0wGBgO/LrKvhOAE9K+s4Efp/iGAJcAx6b4ZgHblisgnZFdD/whxToB+K2kTSoc8w/ATGBIinX/gvXqMp7srG71VNYVklbI7xAR1wI/Af6YmtU2Ky1E0orA5cA5qazJwKdyuywHTCI7Sx1JdnZ5air/u8BfgcNT+Yf34HOwOnCCsKKeJvuPXs99hgDzKuw3j6z5Ku+nwG4FvhR2AR6JiPPSWclk4GFgt9w+kyLiHxHxGnAR8IEaZXZZRPaltnY6e6p2MfmyiLg9IhYDF+SOsTPwQERclradAjxToYxdgTkRMSnV5U7gUmCv0h0ljQS2BL4fEa9HxDTgqoL16jIzIi6JiEVkiXVlsubD7toaWB44JSIWRcRlwO1dGyPinxFxaUS8mn5c/Bj4SJXyCn8OVj9OEFbUMOCFOu/zPLBWhf3WAubnV0TEfLJfmf+vxjHWBuaWrJubjt0l/4X8KrBajTK7HA0IuF1Zr54vVtm30jHWBv5z1hTZiJlva/rJWQcYp6zDwEuSXgI+D7ynzL5rAy9GxCu5daWfQy35uN5Mca3dzTK6Ynkq3j4a6H/KltRf0hmS5kpaAEwDBknqV6G87nwOVidOEFaTpC3Jvlwr/lqWtBrZhei/1ijuU7l9/kL2n35EfgdJW5E1O0wr8/7/AT4KbFHlGE+TfaHkjSRrploqEfFMRBwcEWuTXUz/bdHrIjnzyJqnAJCk/HKJJ4GbI2JQ7rFaRHylQrmDSzoKjMy9fgXonztuP955lpbvKbZciuvpMseqNQz0PGBYqts7yga+CWwIjIuIgcCHuw5bofzufA5WJ04QVpGkgZJ2BS4Ezo+I+8rss5KkLYArgBfJ2pVL9+mXLp7+GtiOrF2eiPgLcANwqaRN0n5bkzXHnBsRs0rLioiXyHo4HV0l9GuADSR9TtLykvYGxgBXF699eZI+03Uxlay+ASzpZjF/At4vaQ9JywNfpfIv4avJ6vIFSSukx5aSNi7dMSLmAjOAEyStKOlDvL1Z7R9kF6F3SdcVvgesVFLMFpL2THEdBbwO3FYmrmeBUcp1fy5xK9nncnj6G4wHtsptH0B23eGldM3o+DLl5zspFP4crH6cIKycqyQtJPvV9l2ytujS3klHp31eAM4luzC6bUnzxjaS/gUsAKYCA4EtSxLNp4GbgGuBf5N9sVwLHFIlvpOp8qUcEf8ka7P+JvBPsmSya0Q8X6XMorYEpqd6TQGOjIjHu1NAiuMzwEkpvjFkX+yvl9l3IVlPr33Ifsk/A/yMd36xd/kcMI7s73I82d+mq6yXgcOAM8nOpl7hnU1bV5L1WnuRrMvxnul6RKmL0/M/Jd1ZJu43gD2BLwEvkfVMuzpXx18Bq5A1M95G9jfPOxnYK/VwOqUHn4PVgTxhkLUSSb8na87aOX3JtL30K7wT+HxE3FTnsn8AvDci9q1nuT2MZTpwekS84yzTWpPPIKzVHETWnXFsswNpJEmflDRI0kpk9xSI8k05yyxJH5H0ntTEtD+wKe88U7AWtnyzAzDLS80ZP2t2HL1gG7I+/SsCDwJ7pC637WRDsi7EqwGPAntFRKVuzdaC3MRkZmZluYnJzMzKaqsmpiFDhsSoUaOaHYaZ2TJj5syZz0dE6f0wQJsliFGjRjFjxoxmh2FmtsyQVPFuezcxmZlZWU4QZmZWlhOEmZmV5QRhZmZlOUGYmVlZThBmZlaWE4SZmZXlBGFmZmU5QZiZWVk1E0Sa7cnMzPqYImcQ0yVdLGnnkvllzcysjRVJEBsAE8mmH5wt6SeSNmhsWGZm1mw1E0Rkro+ICWSzfe0P3C7pZknbNDxCMzNripqjuUpag2zC8S8AzwJHkE3W/gGyictHNzA+MzNrkiLDfd8KnEc2JWJnbv0MSac3JiwzM2u2Igliw6gwL2lE9IW5g83M+qSKCULSVUCk1+/YHhG7Ny4sMzNrtmpnED9Pz3sC7wHOT8sTgDkNjMnMzFpAxQQRETcDSPphRHw4t+kqSdMaHpmZmTVVkfsghkpat2tB0mig7ATXZmbWPopcpP46MFXSY2l5FPDlhkVkZmYtoWaCiIhrJa0PbJRWPRwRrzc2LDMza7Yig/X1B74NHB4R9wAjJe3a8MjMzKypilyDmAS8AXQNq9EJ/KjWmySdLek5SfdX2C5Jp0iaLeleSWNLtveTdJekqwvEaGZmdVYkQawXEScBiwAi4jWgyKiu5wA7Vtm+E7B+ehwCnFay/UjgoQLHMTOzBiiSIN6QtApv3TS3HlDzGkRETANeqLLLeODcNBjgbcAgSWulYwwHdgHOLBCfmZk1QJEEcTxwLTBC0gXADcDRdTj2MODJ3HJnWgfwq3SMN2sVIukQSTMkzZg/f34dwjIzMyg23Pf1ZHdTHwBMBjoiYmodjl2umSrSBfDnImJmkUIiYmJEdEREx9Chvj3DzKxeivRiEtn1gi0i4mqgv6St6nDsTmBEbnk48DTwQWB3SXOAC4HtJZ3/zrebmVkjFWli+i1ZD6YJaXkh8Js6HHsKsF/qzbQ18HJEzIuIYyNieESMAvYBboyIfetwPDMz64Yid1KPi4ixku4CiIgXJa1Y602SJgPbAUMkdZJdy1ghlXE6cA2wMzAbeBU4sEc1MDOzhiiSIBZJ6sdbvZiGUuDicZqitNr2AL5aY5+pwNQCMZqZWZ0VaWI6BbgcWFPSj4FbgJ80NCozM2u6qmcQkpYDHifrcroDWc+jPSLCN7CZmbW5qgkiIt6U9IuI2AZ4uJdiMjOzFlCkiek6SZ9WuXlHzcysbRW5SP0NYFVgsaR/kzUzRUQMbGhkZmbWVEXmgxjQG4GYmVlrqZkgSofhTl4G5kbE4vqHZGZmraBIE9NvgbHAfWn5/cA9wBqSDo2I6xoVnJmZNU+Ri9RzgM0jYouI2AL4AHA/8DHgpMaFZmZmzVQkQWwUEQ90LUTEg2QJ47HGhWVmZs1WpIlplqTTyEZWBdgb+IeklUizzJmZWfspcgZxANmAekcBXwceS+sWAR9tUFxmZtZkRbq5vgb8Ij1K/avuEZmZWUsocgZhZmZ9kBOEmZmV5QRhZmZlFbmTegPg28A6+f0jYvsGxmVmZk1WpJvrxcDpwO+AJY0Nx8zMWkWRBLE4Ik5reCRmZtZSilyDuErSYZLWkrR616PhkZmZWVMVOYPYPz1/O7cugHXrH46ZmbWKIjfKje6NQMzMrLUU6cW0AvAV4MNp1VTgjIjwOExmZm2sSBPTacAKZPNCAHwhrTuoUUGZmVnzFUkQW0bEZrnlGyXd06iAzMysNRTpxbRE0npdC5LWxfdDmJm1vSJnEN8GbpL0GCCyO6oPbGhUZmbWdEV6Md0gaX1gQ7IE8XBEvN7wyMzMrKkqJghJe1bYtJ4kIuKyBsVkZmYtoNoZxG5VtgXgBGFm1sYqJoiIWKrrDJLOBnYFnouI95XZLuBkYGfgVeCAiLhT0gjgXOA9wJvAxIg4eWliMTOz7qvWxLRvRJwv6RvltkfEL2uUfQ5wKtmXfTk7AeunxziyeyvGAYuBb6ZkMQCYKen6iHiwxvHMzKyOqjUxrZqeB/Sk4IiYJmlUlV3GA+dGRAC3SRokaa2ImAfMS2UslPQQMAxwgjAz60XVmpjOSM8nNOjYw4Anc8udad28rhUpwWwOTK9UiKRDgEMARo4c2Yg4zcz6pJo3ykk6SdJASStIukHS85L2rcOxVWZd5I67GnApcFRELKhUSERMjIiOiOgYOnRoHcIyMzModif1J9IX9K5kv/K7piBdWp3AiNzycOBp+M8AgZcCF7g7rZlZcxRJECuk552ByRHxQp2OPQXYT5mtgZcjYl7q3XQW8FCBC+FmZtYgRYbauErSw8BrwGGShgL/rvUmSZOB7YAhkjqB40nJJiJOB64hSzqzybq5dnWr/SDZiLH3Sbo7rTsuIq4pWCczM6sDZZ2IauwkDQYWRMQSSf2BgRHxTMOj66aOjo6YMWNGs8MwM1tmSJoZER3lthWZMGhlsl/3H5IUwC1k9yyYmVkbK9LEdC6wEPh1Wp4AnAd8plFBmZlZ8xVJEBuWTBh0kycMMjNrf0V6Md2VehkBIGkc8LfGhWRmZq2gyBnEOLLuqE+k5ZHAQ5LuAyIiNm1YdGZm1jRFEsSODY/CzMxaTs0mpoiYS3bH8/bp9SvAchExNy2bmVkbKjIW0/HAd4Bj06oVgfMbGZSZmTVfkYvUnwJ2JztzICKepodDgJuZ2bKjSIJ4I83ZEACSVq2xv5mZtYEiCeIiSWcAgyQdDPwF+F1jwzIzs2ar2YspIn4u6ePAAmBD4L8j4vqGR2ZmZk1VpJsrKSE4KZiZ9SFFmpjMzKwPcoIwM7OyitwHcWSRdWZm1l6KnEHsX2bdAXWOw8zMWkzFi9SSJgCfA0ZLmpLbNAD4Z6MDMzOz5qrWi+nvwDxgCPCL3PqFwL2NDMrMzJqvYoJIA/HNBbbpvXDMzKxVFJmTeiFpmA2ygfpWAF6JiIGNDMzMzJqryJ3UbxuYT9IewFaNCsjMzFpDt++DiIgrgO3rH4qZmbWSIk1Me+YWlwM6eKvJyczM2lSRsZh2y71eDMwBxjckGjMzaxlFrkEc2BuBmJlZayky1MZwSZdLek7Ss5IulTS8N4IzM7PmKXKRehIwBVgbGAZcldaZmVkbK5IghkbEpIhYnB7nAEMbHJeZmTVZkQTxvKR9JfVLj33xWExmZm2vSIL4IvBZ4BmysZn2SuvMzKyN1UwQEfFEROweEUMjYs2I2CON01SVpLPThe37K2yXpFMkzZZ0r6SxuW07SpqVth3TvSqZmVk9FLlRbihwMDAqv39E1DqLOAc4FTi3wvadgPXTYxxwGjBOUj/gN8DHgU7gDklTIuLBWrGamVn9FLlR7krgr8BfgCVFC46IaZJGVdllPHBuRARwm6RBktYiS0SzI+IxAEkXpn2dIMzMelGRBNE/Ir7TgGMPA57MLXemdeXWj6tUiKRDgEMARo4cWf8ozcz6qCIJ4mpJO0fENXU+tsqsiyrry4qIicBEgI6Ojh6NEXXCVQ/w4NMLevJWM7OmG7P2QI7fbZO6l1ttytGueSAEHCfpdWBRWo46zAfRCYzILQ8Hniabc6LcejMz60XVZpQbUGlbnUwBDk/XGMYBL0fEPEnzgfUljQaeAvYhmxu7YRqRec3MlnVFejHdEBE71FpX5n2Tge2AIZI6gePJZqMjIk4HrgF2BmYDrwIHpm2LJR0O/BnoB5wdEQ90s15mZraUqjUxrQysSvYFP5i3rg0MJBuXqaqImFBjewBfrbDtGrIEYmZmTVLtDOLLwFFkyeDO3PoFZPcpmJlZG6t2DeJk4GRJR0TEr3sxJjMzawHVmpi2j4gbgadKph0FICIua2hkZmbWVNWamD4C3MjbpxztEoAThJlZG6vWxHR8evaUo2ZmfVCRbq6PAreRjcc0zYPmmZn1DUXmgxgDnAGsAfxc0mOSLm9sWGZm1mxFEsQSsiE2lgBvAs8CzzUyKDMza74ig/UtAO4Dfgn8LiI83aiZWR9Q5AxiAjANOAy4UNIJkqoOs2FmZsu+mmcQEXElcKWkjchmgTsKOBpYpbGhmZlZM9U8g5B0aerJdDLZ2Ez7AYMbHZiZmTVXkWsQJwJ3RkTh6UbNzGzZV6SJ6Y7eCMTMzFpLkYvUZmbWBzlBmJlZWUUvUu8iycnEzKwPKfKlfxrZnNCPSDoxdXc1M7M2VzNBRMRfIuLzwFhgDnC9pL9LOlDSCo0O0MzMmqNQs5GkNYADgIOAu8juiRgLXN+wyMzMrKmKDPd9GbARcB6wW0TMS5v+KGlGI4MzM7PmKXKj3Klp6tF3iIiOOsdjZmYtokgT08aSBnUtSBos6bDGhWRmZq2gSII4OCJe6lqIiBeBgxsWkZmZtYQiCWI5SepakNQPWLFxIZmZWSsocg3iz8BFkk4HAjgUuLahUZmZWdMVSRDfAb4MfAUQcB1wZiODMjOz5isymuubZHdTn9b4cMzMrFVUTBCSLoqIz0q6j6xp6W0iYtOGRmZmZk1V7QziyPS8a28EYmZmraViL6auO6YjYm65R5HCJe0oaZak2ZKOKbN9sKTLJd0r6XZJ78tt+7qkByTdL2mypJV7UkEzM+uZiglC0kJJC3KPhfnnWgWn7rC/AXYCxgATJI0p2e044O7UXLUf2RhPSBoGfA3oiIj3Af2AfXpSQTMz65mKTUwRMWApy94KmB0RjwFIuhAYDzyY22cM8NN0vIcljZL07lxsq0haBPQHnl7KeMzMrBuKjua6maTD06PoxelhwJO55c60Lu8eYM90jK2AdYDhEfEU8HPgCWAe8HJEXFfwuGZmVgdFZpQ7ErgAWDM9LpB0RIGyVWZdaW+oE4HBku4GjiAbSnyxpMFkZxujgbWBVSXtWyG+QyTNkDRj/vz5BcIyM7Miitwo9yVgXES8AiDpZ8CtwK9rvK8TGJFbHk5JM1FELAAOTOUKeDw9Pgk8HhHz07bLgG2B80sPEhETgYkAHR0d7+iOa2ZmPVOkiUnAktzyEsqfHZS6A1hf0mhJK5JdZJ7ytoKlQWkbZJMRTUtJ4wlga0n9U+LYAXiowDHNzKxOipxBTAKmS7qcLDGMB86q9aaIWCzpcLKxnPoBZ0fEA5IOTdtPBzYGzpW0hOzi9ZfStumSLgHuBBaTNT1N7G7lzMys5xRRu1VG0ljgQ2nxrxFxV0Oj6qGOjo6YMcOT3JmZFSVpZqXJ3wr1Yuoqh+wic5HmJTMzW8YV6cX038DvgcHAEGCSpO81OjAzM2uuItcgJgCbR8S/ASSdSHZt4EeNDMzMzJqrSBPTHCA/DtJKwKMNicbMzFpGkTOI14EHJF1Pdg3i48Atkk4BiIivNTA+MzNrkiIJ4vL06DK1MaGYmVkrKTKj3O97IxAzM2st3enmamZmfYgThJmZlVVtwqDz0vORlfYxM7P2Ve0MYgtJ6wBfTFODrp5/9FaAZmbWHNUuUp8OXAusC8zk7UNsRFpvZmZtquIZREScEhEbk43Cum5EjM49nBzMzNpckW6uX5G0GfBfadW0iLi3sWGZmVmzFRms72v0bMpRMzNbhhW5k/ogejblqJmZLcMaOeWomZktw7o75SjAHhSYctTMzJZtRS5S/1LSVLIpRwUc2KpTjpqZWf0UOYMgIu4kmyTIzMz6CI/FZGZmZTlBmJlZWUXugzhc0uDeCMbMzFpHkTOI9wB3SLpI0o6S3MXVzKwPqJkgIuJ7wPpkXVsPAB6R9BNJ6zU4NjMza6JC1yAiIoBn0mMxMBi4RNJJDYzNzMyaqGY31zQW0/7A88CZwLcjYpGk5YBHgKMbG6KZmTVDkfsghgB7RsTc/MqIeFPSro0Jy8zMmq1IE9Po0uTQNR1pRDzUkKjMzKzpiiSITfILkvoBWzQmHDMzaxUVE4SkYyUtBDaVtCA9FgLPAVf2WoRmZtYU1aYc/WlEDAD+JyIGpseAiFgjIo4tUni6b2KWpNmSjimzfbCkyyXdK+l2Se/LbRsk6RJJD0t6SNI2PaqhmZn1SMWL1JI2ioiHgYsljS3dngbwqyg1Rf0G+DjQSXaz3ZSIeDC323HA3RHxKUkbpf13SNtOBq6NiL0krQj0707FzMxs6VTrxfRN4GDgF2W2BbB9jbK3AmZHxGMAki4ExgP5BDEG+ClARDwsaZSkdwOvAR8muzGPiHgDeKNWZczMrH4qJoiIODg9f7SHZQ8DnswtdwLjSva5B9gTuEXSVsA6wHCyWevmA5MkbQbMBI7smvY0T9IhwCEAI0eO7GGoZmZWqloT057V3hgRl9Uou9yYTVGyfCJwsqS7gfuAu8ju1F4BGAscERHTJZ0MHAN8v0wcE4GJAB0dHaXlm5lZD1VrYtqtyrYAaiWITmBEbnk48PTbColYABwIkAYBfDw9+gOdETE97XoJWYIwM7NeUq2J6cClLPsOYH1Jo4GngH2Az+V3kDQIeDVdYzgImJaSxgJJT0raMCJmkV24fhAzM+s1RcZiejfwE2DtiNhJ0hhgm4g4q9r7ImKxpMOBPwP9gLMj4gFJh6btpwMbA+dKWkKWAL6UK+II4ILUg+kx0pmGmZn1DmUDtVbZQfo/YBLw3YjYTNLywF0R8f7eCLA7Ojo6YsaMGc0Ow8xsmSFpZkR0lNtWZKiNIRFxEfAmZGcGZL2MzMysjRVJEK9IWoPUA0nS1sDLDY3KzMyarshw398ApgDrSfobMBTYq6FRmZlZ09VMEBFxp6SPABuS3dswKyIWNTwyMzNrqp7cKLeBpCI3ypmZ2TKsyI1yawLbAjem5Y8CU6l9o5yZmS3Dat4oJ+lqYExEzEvLa5GNumpmZm2sSC+mUV3JIXkW2KBB8ZiZWYso0otpqqQ/A5PJurruA9zU0KjMzKzpivRiOjxdsP6vtGpiRFze2LDMzKzZipxBdPVY8kVpM7M+pFo311si4kOSFvL2eRwEREQMbHh0ZmbWNNXOID4PEBEDeikWMzNrIdV6Mf3nOoOkS3shFjMzayHVEkR+ytB1Gx2ImZm1lmoJIiq8NjOzPqDaNYjNJC0gO5NYJb0GX6Q2M+sTqg210a83AzEzs9ZSZKgNMzPrg5wgzMysLCcIMzMrywnCzMzKcoIwM7OynCDMzKwsJwgzMyvLCcLMzMpSRPuMoiFpPjC3h28fAjxfx3CWBa5z3+A6t7+lqe86ETG03Ia2ShBLQ9KMiOhodhy9yXXuG1zn9teo+rqJyczMynKCMDOzspwg3jKx2QE0gevcN7jO7a8h9fU1CDMzK8tnEGZmVpYThJmZldXnE4SkHSXNkjRb0jHNjqdeJI2QdJOkhyQ9IOnItH51SddLeiQ9D86959j0OcyS9MnmRb90JPWTdJekq9NyW9dZ0iBJl0h6OP29t+kDdf56+nd9v6TJklZutzpLOlvSc5Luz63rdh0lbSHpvrTtFEkqHERE9NkH0A94FFgXWBG4BxjT7LjqVLe1gLHp9QDgH8AY4CTgmLT+GOBn6fWYVP+VgNHpc+nX7Hr0sO7fAP4AXJ2W27rOwO+Bg9LrFYFB7VxnYBjwOLBKWr4IOKDd6gx8GBgL3J9b1+06ArcD25BNF/1/wE5FY+jrZxBbAbMj4rGIeAO4EBjf5JjqIiLmRcSd6fVC4CGy/1jjyb5QSM97pNfjgQsj4vWIeByYTfb5LFMkDQd2Ac7MrW7bOksaSPZFchZARLwRES/RxnVOlgdWkbQ80B94mjarc0RMA14oWd2tOkpaCxgYEbdGli3Ozb2npr6eIIYBT+aWO9O6tiJpFLA5MB14d0TMgyyJAGum3drls/gVcDTwZm5dO9d5XWA+MCk1q50paVXauM4R8RTwc+AJYB7wckRcRxvXOae7dRyWXpeuL6SvJ4hybXFt1e9X0mrApcBREbGg2q5l1i1Tn4WkXYHnImJm0beUWbdM1Znsl/RY4LSI2Bx4hazpoZJlvs6p3X08WVPK2sCqkvat9pYy65apOhdQqY5LVfe+niA6gRG55eFkp6ptQdIKZMnhgoi4LK1+Np12kp6fS+vb4bP4ILC7pDlkzYXbSzqf9q5zJ9AZEdPT8iVkCaOd6/wx4PGImB8Ri4DLgG1p7zp36W4dO9Pr0vWF9PUEcQewvqTRklYE9gGmNDmmukg9Fc4CHoqIX+Y2TQH2T6/3B67Mrd9H0kqSRgPrk13cWmZExLERMTwiRpH9LW+MiH1p7zo/AzwpacO0agfgQdq4zmRNS1tL6p/+ne9Ado2tnevcpVt1TM1QCyVtnT6r/XLvqa3ZV+qb/QB2Juvh8yjw3WbHU8d6fYjsVPJe4O702BlYA7gBeCQ9r557z3fT5zCLbvR0aMUHsB1v9WJq6zoDHwBmpL/1FcDgPlDnE4CHgfuB88h677RVnYHJZNdYFpGdCXypJ3UEOtLn9ChwKmkEjSIPD7VhZmZl9fUmJjMzq8AJwszMynKCMDOzspwgzMysLCcIMzMrywnCrAJJSyTdnXtUHe1X0qGS9qvDcedIGrK05ZgtLXdzNatA0r8iYrUmHHcO0BERz/f2sc3yfAZh1k3pF/7PJN2eHu9N638g6Vvp9dckPSjpXkkXpnWrS7oirbtN0qZp/RqSrkuD7Z1BbvwcSfumY9wt6QxJ/ZpQZeujnCDMKlulpIlp79y2BRGxFdmdqb8q895jgM0jYlPg0LTuBOCutO44sqGXAY4HbolssL0pwEgASRsDewMfjIgPAEuAz9ezgmbVLN/sAMxa2Gvpi7mcybnn/y2z/V7gAklXkA1/AdnwJ58GiIgb05nDu8jmc9gzrf+TpBfT/jsAWwB3pEnAVuGtwdnMGs4JwqxnosLrLruQffHvDnxf0iZUH3q5XBkCfh8Rxy5NoGY95SYms57ZO/d8a36DpOWAERFxE9nkRYOA1YBppCYiSdsBz0c2R0d+/U5kg+1BNhjbXpLWTNtWl7ROw2pkVsJnEGaVrSLp7tzytRHR1dV1JUnTyX5kTSh5Xz/g/NR8JOB/I+IlST8gm/ntXuBV3hq2+QRgsqQ7gZvJhrMmIh6U9D3gupR0FgFfBebWuZ5mZbmbq1k3uRuq9RVuYjIzs7J8BmFmZmX5DMLMzMpygjAzs7KcIMzMrCwnCDMzK8sJwszMyvr/ewRlPueuQOsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.plot(evaluate_average_fidelity[-1000:])\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy without epsilon greedy')\n",
    "plt.title('DDDQN on  single qubit gate')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7cfb7c60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fidelity =  0.9989179073765654\n",
      "[[ 0.01665338-1.11265923e-03j  0.99966709-1.07552856e-16j\n",
      "  -0.01954157+2.29625712e-03j]\n",
      " [ 0.99920221-1.38987934e-02j -0.01682588-2.43265530e-04j\n",
      "  -0.00453551+3.31365328e-02j]\n",
      " [ 0.0334381 -2.25623342e-03j  0.00352393-1.92387942e-02j\n",
      "   0.09197528-9.95004925e-01j]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_sequence(action_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a0051a3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
